home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / misc / gnuplot-3.7src.lha / gnuplot-3.7src / gnuplot-3.7.lha / gnuplot-3.7 / term / tek.trm < prev    next >
Text File  |  1998-12-14  |  19KB  |  759 lines
  1. /*
  2.  * $Id: tek.trm,v 1.20 1998/04/14 00:18:07 drd Exp $
  3.  *
  4.  */
  5.  
  6. /* GNUPLOT - tek.trm */
  7.  
  8. /*[
  9.  * Copyright 1990 - 1993, 1998
  10.  *
  11.  * Permission to use, copy, and distribute this software and its
  12.  * documentation for any purpose with or without fee is hereby granted,
  13.  * provided that the above copyright notice appear in all copies and
  14.  * that both that copyright notice and this permission notice appear
  15.  * in supporting documentation.
  16.  *
  17.  * Permission to modify the software is granted, but not the right to
  18.  * distribute the complete modified source code.  Modifications are to
  19.  * be distributed as patches to the released version.  Permission to
  20.  * distribute binaries produced by compiling modified sources is granted,
  21.  * provided you
  22.  *   1. distribute the corresponding source modifications from the
  23.  *    released version in the form of a patch file along with the binaries,
  24.  *   2. add special version identification to distinguish your version
  25.  *    in addition to the base release version number,
  26.  *   3. provide your name and address as the primary contact for the
  27.  *    support of your modified version, and
  28.  *   4. retain our contact information in regard to use of the base
  29.  *    software.
  30.  * Permission to distribute the released version of the source code along
  31.  * with corresponding source modifications in the form of a patch file is
  32.  * granted with same provisions 2 through 4 for binary distributions.
  33.  *
  34.  * This software is provided "as is" without express or implied warranty
  35.  * to the extent permitted by applicable law.
  36. ]*/
  37.  
  38. /*
  39.  * This file is included by ../term.c.
  40.  *
  41.  * This terminal driver supports:
  42.  *  tek40xx, bitgraph, kermit_color_tek40xx, kermit_mono_tek40xx, selanar
  43.  *  ln03plus
  44.  *
  45.  * AUTHORS
  46.  *   Colin Kelley, Thomas Williams, Russell Lang
  47.  * 
  48.  * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
  49.  * 
  50.  */
  51.  
  52. /*
  53.  * Modified June 1995 Ian MacPhedran to support newterm format
  54.  */
  55. #define TEK
  56. #define CTEK
  57. #define VTTEK
  58. #define KERMIT
  59. #define SELANAR
  60. #define BITGRAPH
  61.  
  62. #include "driver.h"
  63.  
  64. #ifdef TERM_REGISTER
  65. register_term(tek40)
  66. #ifdef VTTEK
  67. register_term(vttek)
  68. #endif
  69. #ifdef KERMIT
  70. register_term(kc_tek40)
  71. register_term(km_tek40)
  72. #endif
  73. #ifdef SELANAR
  74. register_term(selanar)
  75. #endif
  76. #ifdef BITGRAPH
  77. register_term(bitgraph)
  78. #endif
  79. #endif /* TERM_REGISTER */
  80.  
  81. #ifdef TERM_PROTO
  82. TERM_PUBLIC void TEK40init __PROTO((void));
  83. TERM_PUBLIC void TEK40graphics __PROTO((void));
  84. TERM_PUBLIC void TEK40text __PROTO((void));
  85. TERM_PUBLIC void TEK40linetype __PROTO((int linetype));
  86. TERM_PUBLIC void TEK40move __PROTO((unsigned int x, unsigned int y));
  87. TERM_PUBLIC void TEK40vector __PROTO((unsigned int x, unsigned int y));
  88. TERM_PUBLIC void TEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  89. TERM_PUBLIC void TEK40reset __PROTO((void));
  90. TERM_PUBLIC void BG_text __PROTO((void));
  91. TERM_PUBLIC void BG_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  92. TERM_PUBLIC void KTEK40graphics __PROTO((void));
  93. TERM_PUBLIC void KTEK40Ctext __PROTO((void));
  94. TERM_PUBLIC void KTEK40Clinetype __PROTO((int linetype));
  95. TERM_PUBLIC void KTEK40Mlinetype __PROTO((int linetype));
  96. TERM_PUBLIC void KTEK40reset __PROTO((void));
  97. TERM_PUBLIC void SEL_init __PROTO((void));
  98. TERM_PUBLIC void SEL_graphics __PROTO((void));
  99. TERM_PUBLIC void SEL_text __PROTO((void));
  100. TERM_PUBLIC void SEL_reset __PROTO((void));
  101. TERM_PUBLIC void VTTEK40init __PROTO((void));
  102. TERM_PUBLIC void VTTEK40reset __PROTO((void));
  103. TERM_PUBLIC void VTTEK40linetype __PROTO((int linetype));
  104. TERM_PUBLIC void VTTEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  105. TERM_PUBLIC void CTEK_linetype __PROTO((int linetype));
  106. TERM_PUBLIC void CTEK_move __PROTO((unsigned int x, unsigned int y));
  107. TERM_PUBLIC void CTEK_vector __PROTO((unsigned int x, unsigned int y));
  108.  
  109. #endif /* TERM_PROTO */
  110.  
  111. #ifndef TERM_PROTO_ONLY
  112. #ifdef TERM_BODY
  113.  
  114. #ifdef TEK
  115.  
  116. #define TEK40XMAX 1024
  117. #define TEK40YMAX 780
  118.  
  119. #define TEK40XLAST (TEK40XMAX - 1)
  120. #define TEK40YLAST (TEK40YMAX - 1)
  121.  
  122. #define TEK40VCHAR        25
  123. #define TEK40HCHAR        14
  124. #define TEK40VTIC        11
  125. #define TEK40HTIC        11
  126.  
  127. #define HX 0x20            /* bit pattern to OR over 5-bit data */
  128. #define HY 0x20
  129. #define LX 0x40
  130. #define LY 0x60
  131.  
  132. #define LOWER5 31
  133. #define UPPER5 (31<<5)
  134.  
  135.  
  136. TERM_PUBLIC void TEK40init()
  137. {
  138. }
  139.  
  140.  
  141. TERM_PUBLIC void TEK40graphics()
  142. {
  143. #ifdef VMS
  144.     term_pasthru();
  145. #endif /* VMS */
  146.     fputs("\033\014", gpoutfile);
  147. /*                   1
  148.     1. clear screen
  149. */
  150.     (void) fflush(gpoutfile);
  151.     sleep(1);
  152.     /* sleep 1 second to allow screen time to clear on real 
  153.        tektronix terminals */
  154. }
  155.  
  156. TERM_PUBLIC void TEK40text()
  157. {
  158. #ifdef VMS
  159.     (void) fflush(gpoutfile);    /* finish the graphics */
  160. #endif
  161.     TEK40move(0, 12);
  162.     fputs("\037", gpoutfile);
  163. /*                   1
  164.     1. into alphanumerics
  165. */
  166. #ifdef VMS
  167.     term_nopasthru();
  168. #endif /* VMS */
  169. }
  170.  
  171.  
  172. TERM_PUBLIC void TEK40linetype(linetype)
  173. int linetype;
  174. {
  175. }
  176.  
  177. TERM_PUBLIC void TEK40move(x, y)
  178. unsigned int x, y;
  179. {
  180.     (void) putc('\035', gpoutfile);    /* into graphics */
  181.     TEK40vector(x, y);
  182. }
  183.  
  184.  
  185. TERM_PUBLIC void TEK40vector(x, y)
  186. unsigned int x, y;
  187. {
  188.     (void) putc((HY | (y & UPPER5) >> 5), gpoutfile);
  189.     (void) putc((LY | (y & LOWER5)), gpoutfile);
  190.     (void) putc((HX | (x & UPPER5) >> 5), gpoutfile);
  191.     (void) putc((LX | (x & LOWER5)), gpoutfile);
  192. }
  193.  
  194.  
  195. TERM_PUBLIC void TEK40put_text(x, y, str)
  196. unsigned int x, y;
  197. char str[];
  198. {
  199.     TEK40move(x, y - 11);
  200.     fprintf(gpoutfile, "\037%s\n", str);
  201. }
  202.  
  203.  
  204. TERM_PUBLIC void TEK40reset()
  205. {
  206. }
  207.  
  208. #endif /* TEK */
  209.  
  210.  
  211.  
  212. /* thanks to dukecdu!evs (Ed Simpson) for the BBN BitGraph driver */
  213.  
  214. #ifdef BITGRAPH
  215.  
  216. #define BG_XMAX                 768    /* width of plot area */
  217. #define BG_YMAX                 768    /* height of plot area */
  218. #define BG_SCREEN_HEIGHT    1024    /* full screen height */
  219.  
  220. #define BG_XLAST     (BG_XMAX - 1)
  221. #define BG_YLAST     (BG_YMAX - 1)
  222.  
  223. #define BG_VCHAR    16
  224. #define BG_HCHAR     9
  225. #define BG_VTIC         8
  226. #define BG_HTIC         8
  227.  
  228.  
  229. #define BG_init TEK40init
  230.  
  231. #define BG_graphics TEK40graphics
  232.  
  233.  
  234. #define BG_linetype TEK40linetype
  235.  
  236. #define BG_move TEK40move
  237.  
  238. #define BG_vector TEK40vector
  239.  
  240.  
  241. TERM_PUBLIC void BG_text()
  242. {
  243. #ifdef VMS
  244.     (void) fflush(gpoutfile);    /* finish the graphics */
  245. #endif
  246.     BG_move(0, BG_SCREEN_HEIGHT - 2 * BG_VCHAR);
  247.     fputs("\037", gpoutfile);
  248. /*                   1
  249.     1. into alphanumerics
  250. */
  251. }
  252.  
  253.  
  254. TERM_PUBLIC void BG_put_text(x, y, str)
  255. unsigned int x, y;
  256. char str[];
  257. {
  258.     BG_move(x, y - 11);
  259.     fprintf(gpoutfile, "\037%s\n", str);
  260. }
  261.  
  262.  
  263. #define BG_reset TEK40reset
  264.  
  265. #endif /* BITGRAPH */
  266.  
  267.  
  268. /* Color and Monochrome specials for the MS-DOS Kermit Tektronix Emulator
  269.    by Russell Lang,  eln272v@monu1.cc.monash.oz  */
  270.  
  271. #ifdef KERMIT
  272.  
  273. #define KTEK40HCHAR        13
  274.  
  275. TERM_PUBLIC void KTEK40graphics()
  276. {
  277. #ifdef VMS
  278.     term_mode_tek();
  279.     term_pasthru();
  280. #endif /* VMS */
  281.     fputs("\033\014", gpoutfile);
  282. /*                   1
  283.     1. clear screen
  284. */
  285.     /* kermit tektronix emulation doesn't need to wait */
  286. }
  287.  
  288. TERM_PUBLIC void KTEK40Ctext()
  289. {
  290.     TEK40text();
  291.     KTEK40Clinetype(0);        /* change to green */
  292. #ifdef VMS
  293.     term_nopasthru();
  294. #endif /* VMS */
  295. }
  296.  
  297. /* special color linetypes for MS-DOS Kermit v2.31 tektronix emulator */
  298. /*    0 = normal, 1 = bright 
  299.     foreground color (30-37) = 30 + colors
  300.         where colors are   1=red, 2=green, 4=blue */
  301. static char *kermit_color[15] =
  302. {"\033[0;37m", "\033[1;30m",
  303.  "\033[0;32m", "\033[0;36m", "\033[0;31m", "\033[0;35m",
  304.  "\033[1;34m", "\033[1;33m", "\033[1;31m", "\033[1;37m",
  305.  "\033[1;35m", "\033[1;32m", "\033[1;36m", "\033[0;34m",
  306.  "\033[0;33m"};
  307.  
  308. TERM_PUBLIC void KTEK40Clinetype(linetype)
  309. int linetype;
  310. {
  311.     if (linetype >= 13)
  312.     linetype %= 13;
  313.     fprintf(gpoutfile, "%s", kermit_color[linetype + 2]);
  314. }
  315.  
  316.  
  317. /* linetypes for MS-DOS Kermit v2.30 tektronix emulator */
  318. /* `=solid, a=fine dots, b=short dashes, c=dash dot, 
  319.    d=long dash dot, e=dash dot dot */
  320. static char *kerm_linetype = "`a`abcde";
  321.  
  322. TERM_PUBLIC void KTEK40Mlinetype(linetype)
  323. int linetype;
  324. {
  325.     if (linetype >= 6)
  326.     linetype %= 6;
  327.     fprintf(gpoutfile, "\033%c", kerm_linetype[linetype + 2]);
  328. }
  329.  
  330. TERM_PUBLIC void KTEK40reset()
  331. {
  332.     fputs("\030\n", gpoutfile);    /* turn off Tek emulation */
  333. #ifdef VMS
  334.     term_mode_native();
  335. #endif /* VMS */
  336. }
  337.  
  338. #endif /* KERMIT */
  339.  
  340.  
  341. /* thanks to sask!macphed (Geoff Coleman and Ian Macphedran) for the
  342.    Selanar driver */
  343.  
  344. #ifdef SELANAR
  345.  
  346. TERM_PUBLIC void SEL_init()
  347. {
  348.     fputs("\033\062", gpoutfile);
  349. /*                    1
  350.     1. set to ansi mode
  351. */
  352. }
  353.  
  354.  
  355. TERM_PUBLIC void SEL_graphics()
  356. {
  357.     fputs("\033[H\033[J\033\061\033\014", gpoutfile);
  358. /*                   1           2       3
  359.     1. clear ANSI screen
  360.     2. set to TEK mode
  361.     3. clear screen
  362. */
  363. #ifdef VMS
  364.     term_pasthru();
  365. #endif /* VMS */
  366. }
  367.  
  368.  
  369. TERM_PUBLIC void SEL_text()
  370. {
  371. #ifdef VMS
  372.     (void) fflush(gpoutfile);    /* finish the graphics */
  373. #endif
  374.     TEK40move(0, 12);
  375.     fputs("\033\062", gpoutfile);
  376. /*                   1
  377.     1. into ANSI mode
  378. */
  379. #ifdef VMS
  380.     term_nopasthru();
  381. #endif /* VMS */
  382. }
  383.  
  384. TERM_PUBLIC void SEL_reset()
  385. {
  386.     fputs("\033\061\033\012\033\062\033[H\033[J", gpoutfile);
  387. /*                   1        2       3      4
  388. 1       set tek mode
  389. 2       clear screen
  390. 3       set ansi mode
  391. 4       clear screen
  392. */
  393. }
  394.  
  395. #endif /* SELANAR */
  396.  
  397. #ifdef VTTEK
  398.  
  399. TERM_PUBLIC void VTTEK40init()
  400. {
  401.     fputs("\033[?38h", gpoutfile);
  402.     fflush(gpoutfile);
  403.     sleep(1);
  404.     /* sleep 1 second to allow screen time to clear on some terminals */
  405. #ifdef VMS
  406.     term_mode_tek();
  407. #endif /* VMS */
  408. }
  409.  
  410. TERM_PUBLIC void VTTEK40reset()
  411. {
  412.     fputs("\033[?38l", gpoutfile);
  413.     fflush(gpoutfile);
  414.     sleep(1);
  415.     /* sleep 1 second to allow screen time to clear on some terminals */
  416. #ifdef VMS
  417.     term_mode_native();
  418. #endif /* VMS */
  419. }
  420.  
  421. /* linetypes for VT-type terminals in tektronix emulator mode */
  422. /* `=solid, a=fine dots, b=short dashes, c=dash dot,
  423.    d=long dash dot, h=bold solid, i=bold fine dots, j=bold short dashes,
  424.    k=bold dash dot, l=bold long dash dot */
  425. static char *vt_linetype = "`a`abcdhijkl";
  426. static int last_vt_linetype = 0;
  427. TERM_PUBLIC void VTTEK40linetype(linetype)
  428. int linetype;
  429. {
  430.     if (linetype >= 10)
  431.     linetype %= 10;
  432.     fprintf(gpoutfile, "\033%c", vt_linetype[linetype + 2]);
  433.     last_vt_linetype = linetype;
  434. }
  435.  
  436. TERM_PUBLIC void VTTEK40put_text(x, y, str)
  437. unsigned int x, y;
  438. char str[];
  439. {
  440.     int linetype;
  441.     linetype = last_vt_linetype;
  442.     VTTEK40linetype(0);
  443.     TEK40put_text(x, y, str);
  444.     VTTEK40linetype(linetype);
  445. }
  446.  
  447. #endif /* VTTEK */
  448.  
  449. #ifdef LN03P
  450.  
  451. TERM_PUBLIC void LN03Pinit()
  452. {
  453.     fputs("\033[?38h", gpoutfile);
  454. }
  455.  
  456. TERM_PUBLIC void LN03Preset()
  457. {
  458.     fputs("\033[?38l", gpoutfile);
  459. }
  460.  
  461. #endif /* LN03P */
  462.  
  463.  
  464.  
  465. /* tek40xx (monochrome) with linetype support by Jay I. Choe */
  466. #ifdef CTEK
  467.  
  468. /*#define ABS(A) (((A)>=0)? (A):-(A))*/
  469. #define SIGN(A) (((A) >= 0)? 1:-1)
  470.  
  471. static void CT_solid_vector __PROTO((int x, int y));
  472. static void CT_draw_vpoint __PROTO((int x, int y, int last));
  473. static void CT_pattern_vector __PROTO((int x1, int y1));
  474.  
  475. /* CT_lines are line types defined as bit pattern */
  476. static unsigned long CT_lines[] =
  477. {0xffffffff,            /* solid line */
  478.  0x000fffff,            /* long dash */
  479.  0x00ff00ff,            /* short dash */
  480.  0x00f00fff,            /* dash-dot */
  481.  0x00f07fff,            /* long dash - dot */
  482.  0x07070707,
  483.  0x07ff07ff,
  484.  0x070707ff};
  485.  
  486. /* current line pattern */
  487. static unsigned long *CT_pattern = &CT_lines[0];
  488.  
  489. /* we need to keep track of tek cursor location */
  490. static int CT_last_linetype = 0, CT_last_x, CT_last_y;
  491.  
  492. TERM_PUBLIC void CTEK_linetype(linetype)
  493. int linetype;
  494. {
  495.     if (linetype < 0)
  496.     linetype = 0;
  497.     linetype %= (sizeof(CT_lines) / sizeof(unsigned long));
  498.     CT_pattern = &CT_lines[linetype];
  499.     CT_last_linetype = linetype;
  500. }
  501.  
  502. TERM_PUBLIC void CTEK_move(x, y)
  503. unsigned int x;
  504. unsigned int y;
  505. {
  506.     TEK40move(x, y);
  507.     CT_last_x = x;
  508.     CT_last_y = y;
  509. }
  510.  
  511. static void CT_solid_vector(x, y)
  512. int x;
  513. int y;
  514. {
  515.     TEK40vector(x, y);
  516.     CT_last_x = x;
  517.     CT_last_y = y;
  518. }
  519.  
  520. /*
  521.    simulate pixel draw using tek vector draw.
  522.    delays actual line drawing until maximum line segment is determined
  523.    (or first/last point is defined)
  524. */
  525. static int CT_penon = 0;    /* is Pen on? */
  526.  
  527. static void CT_draw_vpoint(x, y, last)
  528. int x;
  529. int y;
  530. int last;
  531. {
  532.     static int xx0, yy0, xx1, yy1;
  533.  
  534.     if ((*CT_pattern) & 1) {
  535.     if (CT_penon) {        /* This point is a continuation of current line */
  536.         xx1 = x;
  537.         yy1 = y;
  538.     } else {        /* beginning of new line */
  539.         xx0 = xx1 = x;
  540.         yy0 = yy1 = y;
  541.         CT_penon = 1;
  542.     }
  543.     *CT_pattern = ((*CT_pattern) >> 1) | 0x80000000;    /* rotate the pattern */
  544.     if (last) {        /* draw the line anyway if this is the last point */
  545.         TEK40move(xx0, yy0);
  546.         TEK40vector(xx1, yy1);
  547.         CT_penon = 0;
  548.     }
  549.     } else {            /* do not draw this pixel */
  550.     if (CT_penon) {        /* last line segment ended at the previous pixel. */
  551.         /* draw the line */
  552.         TEK40move(xx0, yy0);
  553.         TEK40vector(xx1, yy1);
  554.         CT_penon = 0;
  555.     }
  556.     *CT_pattern = (*CT_pattern) >> 1;    /* rotate the current pattern */
  557.     }
  558. }
  559.  
  560. /*
  561.    draw vector line with pattern
  562. */
  563.  
  564. static void CT_pattern_vector(x1, y1)
  565. int x1;
  566. int y1;
  567. {
  568.     int op;            /* order parameter */
  569.     int x0 = CT_last_x;
  570.     int y0 = CT_last_y;
  571.     int dx = x1 - x0;
  572.     int dy = y1 - y0;
  573.     int ax = ABS(dx) << 1;
  574.     int ay = ABS(dy) << 1;
  575.     int sx = SIGN(dx);
  576.     int sy = SIGN(dy);
  577.  
  578.     if (ax >= ay) {
  579.     for (op = ay - (ax >> 1); x0 != x1; x0 += sx, op += ay) {
  580.         CT_draw_vpoint(x0, y0, 0);
  581.         if (op > 0 || (op == 0 && sx == 1)) {
  582.         op -= ax;
  583.         y0 += sy;
  584.         }
  585.     }
  586.     } else {            /* ax < ay */
  587.     for (op = ax - (ay >> 1); y0 != y1; y0 += sy, op += ax) {
  588.         CT_draw_vpoint(x0, y0, 0);
  589.         if (op > 0 || (op == 0 && sy == 1)) {
  590.         op -= ay;
  591.         x0 += sx;
  592.         }
  593.     }
  594.     }
  595.     CT_draw_vpoint(x0, y0, 1);    /* last point */
  596.     CT_last_x = x1;
  597.     CT_last_y = y1;
  598. }
  599.  
  600. TERM_PUBLIC void CTEK_vector(x, y)
  601. unsigned int x;
  602. unsigned int y;
  603. {
  604.     if (CT_last_linetype <= 0)
  605.     CT_solid_vector(x, y);
  606.     else
  607.     CT_pattern_vector(x, y);
  608. }
  609.  
  610. #endif /* CTEK */
  611. #endif /* TERM_BODY */
  612.  
  613. #ifdef TERM_TABLE
  614.  
  615. TERM_TABLE_START(tek40_driver)
  616. #ifndef CTEK
  617.     "tek40xx", "Tektronix 4010 and others; most TEK emulators",
  618.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  619.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
  620.     TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
  621.     TEK40linetype, TEK40put_text, null_text_angle,
  622.     null_justify_text, line_and_point, do_arrow, set_font_null
  623. #else
  624.     "tek40xx", "Tektronix 4010 and others; most TEK emulators",
  625.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  626.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
  627.     TEK40text, null_scale, TEK40graphics, CTEK_move, CTEK_vector,
  628.     CTEK_linetype, TEK40put_text, null_text_angle,
  629.     null_justify_text, line_and_point, do_arrow, set_font_null
  630. #endif /* CTEK */
  631. TERM_TABLE_END(tek40_driver)
  632.  
  633. #undef LAST_TERM
  634. #define LAST_TERM tek40_driver
  635.  
  636. #ifdef VTTEK
  637. TERM_TABLE_START(vttek_driver)
  638.     "vttek", "VT-like tek40xx terminal emulator",
  639.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  640.     TEK40VTIC, TEK40HTIC, options_null, VTTEK40init, VTTEK40reset,
  641.     TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
  642.     VTTEK40linetype, VTTEK40put_text, null_text_angle,
  643.     null_justify_text, line_and_point, do_arrow, set_font_null
  644. TERM_TABLE_END(vttek_driver)
  645.  
  646. #undef LAST_TERM
  647. #define LAST_TERM vttek_driver
  648.  
  649. #endif /* VTTEK */
  650.  
  651. #ifdef KERMIT
  652. TERM_TABLE_START(kc_tek40_driver)
  653.    "kc_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - color",
  654.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
  655.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
  656.     KTEK40Ctext, null_scale, KTEK40graphics, TEK40move, TEK40vector,
  657.     KTEK40Clinetype, TEK40put_text, null_text_angle,
  658.     null_justify_text, do_point, do_arrow, set_font_null
  659. TERM_TABLE_END(kc_tek40_driver)
  660.  
  661. #undef LAST_TERM
  662. #define LAST_TERM kc_tek40_driver
  663.  
  664. TERM_TABLE_START(km_tek40_driver)
  665.     "km_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - monochrome",
  666.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
  667.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
  668.     TEK40text, null_scale, KTEK40graphics, TEK40move, TEK40vector,
  669.     KTEK40Mlinetype, TEK40put_text, null_text_angle,
  670.     null_justify_text, line_and_point, do_arrow, set_font_null
  671. TERM_TABLE_END(km_tek40_driver)
  672.  
  673. #undef LAST_TERM
  674. #define LAST_TERM km_tek40_driver
  675.  
  676. #endif /* KERMIT */
  677.  
  678. #ifdef SELANAR
  679. TERM_TABLE_START(selanar_driver)
  680.     "selanar", "Selanar",
  681.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  682.     TEK40VTIC, TEK40HTIC, options_null, SEL_init, SEL_reset,
  683.     SEL_text, null_scale, SEL_graphics, TEK40move, TEK40vector,
  684.     TEK40linetype, TEK40put_text, null_text_angle,
  685.     null_justify_text, line_and_point, do_arrow, set_font_null
  686. TERM_TABLE_END(selanar_driver)
  687.  
  688. #undef LAST_TERM
  689. #define LAST_TERM selanar_driver
  690.  
  691. #endif /* SELANAR */
  692.  
  693. #ifdef BITGRAPH
  694. TERM_TABLE_START(bitgraph_driver)
  695.     "bitgraph", "BBN Bitgraph Terminal",
  696.     BG_XMAX, BG_YMAX, BG_VCHAR, BG_HCHAR,
  697.     BG_VTIC, BG_HTIC, options_null, BG_init, BG_reset,
  698.     BG_text, null_scale, BG_graphics, BG_move, BG_vector,
  699.     BG_linetype, BG_put_text, null_text_angle,
  700.     null_justify_text, line_and_point, do_arrow, set_font_null
  701. TERM_TABLE_END(bitgraph_driver)
  702.  
  703. #undef LAST_TERM
  704. #define LAST_TERM bitgraph_driver
  705.  
  706. #endif /* BITGRAPH */
  707.  
  708. #endif /* TERM_TABLE */
  709.  
  710. #endif /* TERM_PROTO_ONLY */
  711.  
  712. #ifdef TERM_HELP
  713. START_HELP(tek40)
  714. "1 tek40",
  715. "?commands set terminal tek40xx",
  716. "?set terminal tek40xx",
  717. "?set term tek40xx",
  718. "?terminal tek40xx",
  719. "?terminal tek40xx",
  720. "?tek40",
  721. "?commands set terminal vttek",
  722. "?set terminal vttek",
  723. "?set term vttek",
  724. "?terminal vttek",
  725. "?term vttek",
  726. "?vttek",
  727. "?commands set terminal kc-tek40xx",
  728. "?set terminal kc-tek40xx",
  729. "?set term kc-tek40xx",
  730. "?terminal kc-tek40xx",
  731. "?term kc-tek40xx",
  732. "?kc-tek40xx",
  733. "?commands set terminal km-tek40xx",
  734. "?set terminal km-tek40xx",
  735. "?set term km-tek40xx",
  736. "?terminal km-tek40xx",
  737. "?term km-tek40xx",
  738. "?km-tek40xx",
  739. "?commands set terminal selanar",
  740. "?set terminal selanar",
  741. "?set term selanar",
  742. "?terminal selanar",
  743. "?term selanar",
  744. "?selanar",
  745. "?commands set terminal bitgraph",
  746. "?set terminal bitgraph",
  747. "?set term bitgraph",
  748. "?terminal bitgraph",
  749. "?term bitgraph",
  750. "?bitgraph",
  751. " This family of terminal drivers supports a variety of VT-like terminals.",
  752. " `tek40xx` supports Tektronix 4010 and others as well as most TEK emulators;",
  753. " `vttek` supports VT-like tek40xx terminal emulators; `kc-tek40xx` supports",
  754. " MS-DOS Kermit Tek4010 terminal emulators in color: `km-tek40xx` supports them",
  755. " in monochrome; `selanar` supports Selanar graphics; and `bitgraph` supports",
  756. " BBN Bitgraph terminals.  None have any options."
  757. END_HELP(tek40)
  758. #endif /* TERM_HELP */
  759.